home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / amok_lha / amok24.lha / DME / SRC / source.zoo / subs.c < prev    next >
C/C++ Source or Header  |  1989-07-03  |  5KB  |  275 lines
  1.  
  2. /*
  3.  *  SUBS.C
  4.  *
  5.  *      (C)Copyright 1987 by Matthew Dillon, All Rights Reserved
  6.  *
  7.  *  Subroutines.
  8.  */
  9.  
  10. #include "defs.h"
  11.  
  12. extern PROC *proc;
  13.  
  14. /*
  15.  *  Create DME's text icon.
  16.  */
  17.  
  18. makemygadget(gad)
  19. register struct Gadget *gad;
  20. {
  21.     static unsigned long ga[] = {
  22.         0xFFFFFFFF,     /* 32 pixels across */
  23.         0x80FDCBFD,
  24.         0xFFFDDFFD,
  25.         0x80000001,
  26.         0x80DFDDDF,
  27.         0x80000001,
  28.         0xBC0EF00B,
  29.         0x80000001,
  30.         0xBFC00CDD,
  31.         0x80000001,
  32.         0xA00DF00F,
  33.         0x80000001,
  34.         0x80000001,
  35.  
  36.         0x80000001,
  37.         0x80FDCBFD,
  38.         0xFFFDDFFD,
  39.         0x80000001,
  40.         0x80DFDDDF,
  41.         0x80000001,
  42.         0xBC0EF00B,
  43.         0x80000001,
  44.         0xBFC00CDD,
  45.         0x80000001,
  46.         0xA00DF00F,
  47.         0x80000001,
  48.         0xFFFFFFFF
  49.     };
  50.     static struct Image image = {
  51.         0, 0, 20, sizeof(ga)/4/2, 2, (unsigned short *)ga, 3, 0, NULL
  52.     };
  53.     bzero(gad, sizeof(struct Gadget));
  54.     gad->Width = 20;
  55.     gad->Height = sizeof(ga)/4/2 + 1;
  56.     gad->Flags  = GADGIMAGE|GADGHCOMP;
  57.     gad->GadgetType   = BOOLGADGET;
  58.     gad->Activation = RELVERIFY|GADGIMMEDIATE;
  59.     gad->GadgetRender = (APTR)ℑ
  60. }
  61.  
  62. /*
  63.  * return index of first non space.  Returns 0 if no spaces found.
  64.  */
  65.  
  66. firstns(str)
  67. register char *str;
  68. {
  69.     register short i;
  70.  
  71.     for (i = 0; str[i] && str[i] == ' '; ++i);
  72.     if (str[i] == 0)
  73.         i = 0;
  74.     return(i);
  75. }
  76.  
  77. /*
  78.  *  Return index of last non-space, 0 if no spaces.
  79.  */
  80.  
  81. lastns(str)
  82. register char *str;
  83. {
  84.     register short i;
  85.  
  86.     for (i = strlen(str) - 1; i > 0 && str[i] == ' '; --i);
  87.     if (i < 0)
  88.         i = 0;
  89.     return(i);
  90. }
  91.  
  92. /*
  93.  *  Return length of word under cursor
  94.  */
  95.  
  96. wordlen(str)
  97. register char *str;
  98. {
  99.     register short i;
  100.  
  101.     for (i = 0; *str && *str != ' '; ++i, ++str);
  102.     return(i);
  103. }
  104.  
  105. /*
  106.  *  Find the path from some root device to a specific filename (src), and
  107.  *  stick the result in (dest).  If unable to backtrace along directories,
  108.  *  simply copy (src) into (dest)
  109.  *
  110.  *  Returns (1) if able to backtrace, (0) if not.
  111.  */
  112.  
  113. getpath(src, dest)
  114. char *src, *dest;
  115. {
  116.     register long flock, pflock;
  117.     register short len, total;
  118.     register FIB *fib = (FIB *)malloc(sizeof(FIB));
  119.     char c;
  120.  
  121.     dest[0] = 0;
  122.     total = 1;
  123.     proc->pr_WindowPtr = (APTR)Ep->Win;
  124.     flock = Lock(src, ACCESS_READ);
  125.     if (flock == NULL) {                           /* missing file?    */
  126.         for (len = strlen(src); len >= 0; --len) {
  127.             if (src[len] == '/') {
  128.                 --len;
  129.                 break;
  130.             }
  131.             if (src[len] == ':')
  132.                 break;
  133.         }
  134.         if (c = src[len + 1]) {
  135.             strcpy(dest, src+len+2);
  136.             total = strlen(dest)+1;
  137.         }
  138.         src[len + 1] = 0;
  139.         flock = Lock(src, ACCESS_READ);
  140.         src[len + 1] = c;
  141.     }
  142.     if (flock) {
  143.         do {
  144.             pflock = ParentDir(flock);
  145.             if (Examine(flock, fib) == 0)
  146.                 fib->fib_FileName[0] = 0;
  147.             if (fib->fib_FileName[0] == 0)
  148.                 strcpy(fib->fib_FileName, "ram");
  149.             len = strlen(fib->fib_FileName);
  150.             bmov(dest, dest + len + 1, total);
  151.             dest[len] = (pflock) ? '/' : ':';
  152.             bmov(fib->fib_FileName, dest, len);
  153.             total += len + 1;
  154.             UnLock(flock);
  155.             flock = pflock;
  156.         } while(pflock);
  157.         len = strlen(dest) - 1;
  158.         if (dest[len] == '/')
  159.             dest[len] = 0;
  160.         return(1);
  161.     }
  162.     strcpy(dest, src);
  163.     return(0);
  164. }
  165.  
  166. int
  167. is_ascii(chr)
  168. char chr;
  169. {
  170.    register ch = chr;
  171.  
  172.    if( (ch >= '0' && ch <= '9') ||
  173.        (ch >= 'A' && ch <= 'Z') ||
  174.        (ch >= 'a' && ch <= 'z') ||
  175.         ch == '_'
  176.      )
  177.        return -1;
  178.    else
  179.        return  0;
  180. }
  181.  
  182. /*
  183.  *  Allocation routines and other shortcuts
  184.  */
  185.  
  186. ubyte *
  187. allocb(bytes)
  188. {
  189.     return(AllocMem(bytes, MEMF_CLEAR|MEMF_PUBLIC));
  190. }
  191.  
  192. ubyte *
  193. allocl(lwords)
  194. {
  195.     return(AllocMem(lwords<<2, MEMF_CLEAR|MEMF_PUBLIC));
  196. }
  197.  
  198. bmovl(s,d,n)
  199. char *s,*d;
  200. {
  201.     bmov(s,d,n<<2);
  202. }
  203.  
  204. /*
  205.  *  Remove tabs in a buffer
  206.  */
  207.  
  208. detab(ibuf, obuf, maxlen)
  209. register char *ibuf, *obuf;
  210. {
  211.     register short i, j;
  212.  
  213.     maxlen -= 2;
  214.     for (i = j = 0; ibuf[i] && j < maxlen; ++i) {
  215.         if (ibuf[i] == 9) {
  216.             do {
  217.                 obuf[j++] = ' ';
  218.             } while ((j & 7) && j < maxlen);
  219.         } else {
  220.             obuf[j++] = ibuf[i];
  221.         }
  222.     }
  223.     while (j && obuf[j-1] == ' ')
  224.         --j;
  225.     obuf[j] = 0;
  226.     return(j);
  227. }
  228.  
  229. xefgets(xfi, buf, max)
  230. char *buf;
  231. long xfi;
  232. {
  233.     char ebuf[256];
  234.     if (xfgets(xfi, ebuf, max) >= 0)
  235.         return(detab(ebuf, buf, max));
  236.     return(-1);
  237. }
  238.  
  239. ncstrcmp(s1, s2)
  240. register ubyte *s1, *s2;
  241. {
  242.     register ubyte c1, c2;
  243.  
  244.     for (;;) {
  245.         c1 = *s1;
  246.         c2 = *s2;
  247.         if (c1 >= 'A' && c1 <= 'Z') c1 |= 0x20;
  248.         if (c2 >= 'A' && c2 <= 'Z') c2 |= 0x20;
  249.         if (c1 != c2)
  250.             break;
  251.         if ((c1|c2) == 0)
  252.             return(0);
  253.         ++s1;
  254.         ++s2;
  255.     }
  256.     if (c1 < c2)
  257.         return(-1);
  258.     if (c1 > c2)
  259.         return(1);
  260. }
  261.  
  262. ED *
  263. finded(str, doff)
  264. char *str;
  265. {
  266.     register ED *ed;
  267.  
  268.     for (ed = (ED *)DBase.mlh_Head; ed->Node.mln_Succ; ed = (ED *)ed->Node.mln_Succ) {
  269.         if (strlen(ed->Name) >= doff && ncstrcmp(str, ed->Name+doff) == 0)
  270.             return(ed);
  271.     }
  272.     return(NULL);
  273. }
  274.  
  275.